home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1997 September / Macworld (1997-09).dmg / Serious Software / Cherwell Scientific Demos / pro Fit / pro Fit 5.0 demo (fpu).sea / pro Fit 5.0 demo (fpu) / External Modules / External modules sources / C / Utility files / ModuleUtilities.h < prev    next >
Text File  |  1996-06-30  |  9KB  |  235 lines
  1. #ifndef __MODULE_UTILITIES__
  2. #define __MODULE_UTILITIES__
  3.  
  4.  
  5. #define maxNrItems 100        /* max number of items in a dialog */
  6.  
  7. typedef enum { unknownItem=0, windowPopupItem, columnPopupItem } ItemType;    // the item types
  8.  
  9.  
  10. typedef struct
  11. {
  12.     ItemType    type;            // the type of an item, unknownItem if item needs no special treatement                
  13.     long        n1;                // used to store special information for some items
  14.                                 //    for dataColumnPopups: 0 if all columns, 1 if only numerical columns, 2 if only text columns
  15.     long        n2;                // used to store special information for some items
  16.                                 //    for dataColumnPopups: 0 or the item id of a corresponding window popup
  17.     long        n3;                // used to store special information for some items
  18.                                 //    for dataColumnPopups: 0 or the windowRefID it was last updated for
  19.     void*        data;            // used to store information on some items
  20.                                 // for windowPopupItem: handle to an array of windowRefIDs
  21. } ItemRecord;
  22.  
  23. typedef struct
  24. {
  25.     WindowPtr        dialog;                    // window pointer to the dialog
  26.     short            okItem, cancelItem;        // the items to be activated on return/cmd-. (0 if none)
  27.     short            itemHit;                // the item to be returned from MyModalDialog
  28.     ItemRecord        items[maxNrItems];        // an array with information on some of the items
  29.     long            timer;                    // != 0 if timer is enabled (see MySetTimer)
  30.     Rect            frames[4];                // rects to frame (0,0,0,0) if no frame (See MySetFrame)
  31. }DialogData;
  32.  
  33. DialogData* MyGetNewDialog(short resID, short okItem, short cancelItem);
  34.     // call instead of GetNewDialog
  35.     // resID:        the resource ID of the DLOG
  36.     // okItem:        the item to be activated when Enter/Return is pressed (0 if none)
  37.     // cancleItem    the item to be activated when Escape/cmd-. is pressed (0 if none)
  38.     // returns nil if failure
  39.  
  40. void MyDisposeDialog(DialogData* dlg);
  41.     // call instead of DisposeDialog
  42.     // dlg: the data returned by MyGetNewDialog
  43.  
  44.  
  45. void MyModalDialog(DialogData* dlg, short* const itemHit);
  46.     // call instead of ModalDialog
  47.     // dlg: the data returned by MyGetNewDialog
  48.     // Automatically toggles checkboxes when clicked
  49.  
  50. void MyShowDialog(DialogData* dlg);
  51.     // makes the dialog visible
  52.  
  53.  
  54. // routines for accessing items:
  55.  
  56. void MyGetItemText(DialogData* dlg, short item, Str255 dest);
  57.     // returns the text in an item
  58.  
  59. void MySetItemText(DialogData* dlg, short item, const Str255 s);
  60.     // sets the text of an item
  61.  
  62. void MySelectItemText(DialogData* dlg, short id, short start, short end);
  63.     // selects a text edit item
  64.  
  65. void MySetExtendedItem(DialogData* dlg, short id, double val);
  66.     // sets a text item to a floating point number
  67.  
  68. Boolean MyGetExtendedItem(DialogData* dlg, short id, double* const val);
  69.     // retrieves a floating point number from a text item
  70.     // if conversion fails: val is unchanged, the text is selected, and false is returned
  71.  
  72. void MySetLongItem(DialogData* dlg, short id, long val);
  73.     // sets a text item to a longint number
  74.  
  75. Boolean MyGetLongItem(DialogData* dlg, short id, long* const val);
  76.     // retrieves a longint number from a text item
  77.     // if conversion fails: val is unchanged, the text is selected, and false is returned
  78.  
  79.  
  80. ControlHandle MyGetItemHandle(DialogData* dlg, short item);
  81.     // returns the control handle of an item
  82.  
  83. void MyHiliteItem(DialogData* dlg, short item, short value);
  84.     // hilites an item (value == 255 for disabling)
  85.  
  86. void MyShowItem(DialogData* dlg, short item);
  87.     // makes the given item visible
  88.  
  89. void MyHideItem(DialogData* dlg, short item);
  90.     // makes the given item invisible
  91.  
  92. Rect MyGetItemRect(DialogData* dlg, short item);
  93.     // returns enclosing rect of an item
  94.  
  95. void MyInvalidateItem(DialogData* dlg, short item);
  96.     // invalidates the given item
  97.  
  98. void MySetItemValue(DialogData* dlg, short item, short value);
  99.     // sets the value of a control an item
  100.  
  101. short MyGetItemValue(DialogData* dlg, short item);
  102.     // gets the value of an item
  103.     
  104. void SetItemGeneral(DialogData* dlg, short item, void* data);
  105.     // generic routine for setting items. Presently recognized by
  106.     //    window popup items:    data must be a pointer to a long value, containing the window ref ID
  107.  
  108. void GetItemGeneral(DialogData* dlg, short item, void* data);
  109.     // generic routine getting the setting of items. Presently recognized by
  110.     //    window popup items:    data must be a pointer to a long value, where the window ref ID is returned
  111.  
  112.  
  113. void FlashControl(ControlHandle control);
  114.     // hilites the control for a moment
  115.  
  116. // special popup items:
  117.  
  118. void MakeWindowPopup(DialogData* dlg, short item, long windowType);
  119.     // adds a list of windows to the given popup item
  120.     // windowType can be drawingType, dataType or textType and defines
  121.     // the window type that should be added to the menu
  122.     // use GetItemGeneral to get the selected window
  123.  
  124. void MakeColumnPopup(DialogData* dlg, short item, short windowPopup, short what);
  125.     // adds a list of column names to a popup item
  126.     //    windowPopup:    the item id of a window popup that this item belongs to, 0 if none
  127.     //    what:            0 if all columns, 1 if only data columns, 2 if only text columns
  128.     // use GetItemValue/SetItemValue to access the column
  129.     // if the column popup belongs to a window popup, first call MakeWindowPopup for the window popup
  130.  
  131. // setting the timer of a dialog:
  132.  
  133. void MySetTimer(DialogData* dlg, long ticks);
  134.     // Each dialog can have a timer, which is disabled by default. To enable the timer,
  135.     // call the routine MySetTimer with a value if ticks that is != 0
  136.     // If the timer is enabled, it MyModalDialog check if TickCount() > ticks. If yes,
  137.     // ticks is reset to 0 and MyModalDialog returns with itemHit = -1.
  138.  
  139. // setting frames
  140.  
  141. void MySetFrame(DialogData* dlg, Rect* const r, short index);
  142.     // Sets a frame that must be drawn whenever the dialog box is updated
  143.     // Set r to nil if you want to clear a frame
  144.     // There are up to 4 frames. Each is identified by its index (0..3)
  145.  
  146. // appending and removing DITLs
  147.  
  148. void MyAppendDITL(DialogData* dlg, short resID);
  149.     // appens DITL of given res-id to dialog
  150.  
  151. void MyShortenDITL(DialogData* dlg, short nrItems);
  152.     // removes a given number of items from dlg
  153.  
  154. // alert boxes
  155.  
  156. short MyAlert(short resID);
  157.     // shows a given alert box, returns the clicked item
  158.     // resID: the res ID of a DLOG
  159.  
  160. short MyPositionedAlert(short resID, Rect* const position);
  161.     // same as MyAlert, but allows setting and storing of window position
  162.     // position: on entry:    the position of the alert window in global coord. or {0,0,0,0}
  163.     //                        for default position
  164.     //             on exit:    the last position of the alert window
  165.  
  166.  
  167.  
  168. // miscellaneous utilities:
  169.  
  170. void AddItemToMenu(MenuHandle menu, Str255 name);
  171.     // adds an item with the given name to the given menu
  172.     // makes sure that the name contains no illegal characters that would mess up the menu
  173.  
  174. double RoundDouble(double x);
  175.     // rounds x to next integer
  176.  
  177.  
  178. // window handling:
  179.  
  180. // this utility package is able to handle several windows at the same time.
  181. // This is only possible if it has a list of its windows and if it knows
  182. // how to handle update and actvate/deactivate events for each window.
  183. // For this purpose, each window that the module creates must be registered 
  184. // by calling RegisterWindow/UnregisterWindow
  185.  
  186. typedef Boolean (*WindowHandler)(long message, void* m, void* param);
  187.     // a routine for handling the window.
  188.     // message tells you what the routine should do. m depends on message.
  189.     // param is the parameter passed to RegisterWindow.
  190.     // The routine must return false if it does not recognize or handle a given message.
  191.     // presently used messages:
  192.     //    'evnt':    Handle a window related event. m points to the event record.
  193.     //            Return true if the event loop should exit, false otherwise.
  194.     //  'grw1':    Called when the grow button was called. m points to a Rect.
  195.     //            set (*m).top/left to the minimum size of the window, 
  196.     //            (*m).bot/right to its maximum size and return true. If the window
  197.     //            cannot be grown, return false.
  198.     //    'grw2':    Called when the window has been resized.
  199.     //    'menu':    Called after click into menu. m points to the long value returned by MenuSelct
  200.     //            If implemented, your handler should return true if we should
  201.     //            exit the event loop.
  202.     // Your WindowHandler must implement the 'evnt' message, all other messages are
  203.     // optional. If you do not handle a message, return false.
  204.  
  205.  
  206. void RegisterWindow(WindowPtr window, WindowHandler handler, void* param);
  207.     // register a private window of this module
  208.     // window: the window ptr to it
  209.     // handler: called for handling window related events, must at least implement update events
  210.     // param: parameter passed each time handler is called
  211.  
  212. void WindowCanGrow(WindowPtr window, Rect* const growRect);
  213.     // if a window can be grow, call this routine after having called RegisterWindow
  214.     // growRect must contain the minimum size of the window in top/left and the
  215.     // maximum size in bottom/right
  216.  
  217. void UnregisterWindow(WindowPtr window);
  218.     // unregister a private window previously registered by RegisterWindow
  219.     // If the window handler routine implements the 'rect' method, the rectangle will
  220.     // be updated to the last position of the window
  221.     // UnregisterWindow must be called before the window is deallocated 
  222.  
  223. void EventLoop(void);
  224.     // Gets events and handles them until a window handler returns true
  225.  
  226. void GetGlobalWindowRect(WindowPtr window, Rect* const r);
  227.     // returns the window's rect in global coordinates
  228.  
  229. void SetGlobalWindowRect(WindowPtr window, Rect* const r);
  230.     // moves the window to the given global coordinates
  231.     
  232.  
  233.  
  234. #endif
  235.